home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / strategy / xpat2-1.000 / xpat2-1 / xpat2-1.04 / src / r_Calculatio.c < prev    next >
C/C++ Source or Header  |  1994-04-22  |  3KB  |  119 lines
  1. /*****************************************************************************/
  2. /*                                         */
  3. /*                                         */
  4. /*    X patience version 2 -- module r_Calculation.c                 */
  5. /*                                         */
  6. /*    Characteristics of the ``Calculation'' rules                 */
  7. /*    written by Michael Bischoff (mbi@mo.math.nat.tu-bs.de)             */
  8. /*    04-Apr-1994                                 */
  9. /*    see COPYRIGHT.xpat2 for Copyright details                 */
  10. /*                                         */
  11. /*                                         */
  12. /*****************************************************************************/
  13. #include "xpatgame.h"
  14.  
  15. #define A 1
  16. #define J 11
  17. #define Q 12
  18. #define K 13
  19.  
  20. static int order[4][13] = {
  21.     { A,2,3,4,5,6,7,8,9,10,J,Q,K },
  22.     { 2,4,6,8,10,Q,A,3,5,7,9,J,K },
  23.     { 3,6,9,Q,2,5,8,J,A,4,7,10,K },
  24.     { 4,8,Q,3,7,J,2,6,10,A,5,9,K } };
  25.  
  26. static void Calc_newgame(void) {
  27.     int i;
  28.     /* specific part: all cards on the vdeck, except 4 starting cards */
  29.     for (i = 0; i <= VDECK; ++i)
  30.     game.ind[i] = rules.numstacks * rules.faceup;
  31.     game.ind[IDECK] = rules.numcards;
  32.     for (i = 0; i < rules.numstacks; ++i)
  33.     game.ind[i] = i * rules.faceup;
  34.     for (i = 0; i < rules.numstacks; ++i) {
  35.     /* swap cards such that first cards are OK */
  36.     int j, rem;
  37.     for (j = 0; j < rules.faceup; ++j) {
  38.         int h;
  39.         rem = rules.numcards;
  40.         do
  41.         --rem;
  42.         while (RANK(game.cards[rem]) != order[i&3][j] - 1);
  43.         h = game.cards[i*rules.faceup+j];
  44.         game.cards[i*rules.faceup+j] = game.cards[rem];
  45.         game.cards[rem] = h;
  46.     }
  47.     }
  48.     for (i = 0; i < rules.numcards; ++i)
  49.     game.visible[i] = 1;
  50. }
  51.  
  52. static int Calc_movevalid(Cardindex src, Pileindex dst) {
  53.     switch (game.piletype[dst]) {
  54.     case Stack:
  55.     return RANK(game.cards[src]) + 1 == order[dst&3][CARDS_ON_PILE(dst)];
  56.     case Slot:
  57.     return game.piletype[getpile(src)] == FaceupDeck;
  58.     default:
  59.     return 0;
  60.     }
  61. }
  62.  
  63. static int Calc_good_hint(Cardindex src, Pileindex dst) {
  64.     switch (game.piletype[dst]) {
  65.     case Stack:
  66.     return 100;
  67.     case Slot:
  68.     return 1;    /* do not display */
  69.     default:
  70.     return 0;
  71.     }
  72. }
  73.  
  74. static void Calc_check(void) {
  75.     if (rules.faceup >= 13) {
  76.     fprintf(stderr, "Calculation cannot be played with more than 12 faceup cards!\n");
  77.     exit(EXIT_FAILURE);
  78.     }
  79. }
  80.  
  81. struct rules Calculation_rules = {
  82.     "Calculation",/* shortname */
  83.     NULL,    /* longname */
  84.     "calc",     /* abbrev */
  85.     0,        /* layout_hints */
  86.     DECK_SOURCE|STACKS_MULTI|NODEAL,/* variant */
  87.     CUSTOM_FACEUP,/* customizable */
  88.     0,        /* customized */
  89.     52,        /* numcards */
  90.     4,        /* numstacks */
  91.     4,        /* numslots */
  92.     0,        /* numtmps */
  93.     1,        /* numdecks */
  94.     13,        /* cards_per_color */
  95.     0,        /* numjokers */
  96.     {0, 0, 0, 0},/* param[0], param[1], param[2], param[3] */
  97.     0,        /* facedown */
  98.     1,        /* faceup */
  99.     0,        /* newgame_bits */
  100.     Calc_newgame,/* new_game */
  101.     NULL,    /* game_won */
  102.     NULL,    /* new_cards */
  103.     MG_NONE|ST_ONE|DC_ALWAYS, /* move_bits */
  104.     NULL,    /* deal_cards */
  105.     NULL,    /* undeal_cards */
  106.     NULL,    /* stackable */
  107.     Calc_movevalid,/* movevalid */
  108.     NULL,    /* valid */
  109.     NULL,    /* relaxed_valid */
  110.     Calc_good_hint,/* good_hint */
  111.     NULL,    /* automove */
  112.     NULL,    /* score */
  113.     0,        /* maxscore */
  114.     {0, 0, 0, 0}, /* paramstring blocks */
  115.     0,        /* used */
  116.     Calc_check,    /* initfunc */
  117.     NULL,    /* local keyboard bindings */
  118. };
  119.